namespace ext.util
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <definedin>src\util\Function.js</definedin>
	/// <definedin>src\util\Function.js</definedin>
	[ScriptName("Functions")]
	[ScriptNamespace("Ext.util")]
	[Imported()]
	public partial class Functions
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		internal Functions()
		{
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// </summary>
		/// <htmlSummary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="origFn">The original function.</param>
		/// <param name="newFn">The function to call before the original</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the passed function is executed.
		/// &lt;b&gt;If omitted, defaults to the scope in which the original function is called or the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createInterceptor")]
		public System.Function CreateInterceptor(System.Delegate origFn, System.Delegate newFn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// </summary>
		/// <htmlSummary>
		/// Creates an interceptor function. The passed function is called before the original one. If it returns false,
		/// the original one is not called. The resulting function returns the results of the original function.
		/// The passed function is called with the parameters of the original function. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// // create a new function that validates input without
		/// // directly modifying the original function:
		/// var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
		/// return name == &apos;Brian&apos;;
		/// });
		///
		/// sayHiToFriend(&apos;Fred&apos;); // no alert
		/// sayHiToFriend(&apos;Brian&apos;); // alerts &quot;Hi, Brian&quot;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="origFn">The original function.</param>
		/// <param name="newFn">The function to call before the original</param>
		/// <returns>The new function</returns>
		[ScriptName("createInterceptor")]
		public System.Function CreateInterceptor(System.Delegate origFn, System.Delegate newFn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;Ext.createDelegate(this.myFunction, this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(System.Delegate fn, object scope, System.Array args, bool appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;Ext.createDelegate(this.myFunction, this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(System.Delegate fn, object scope, System.Array args, System.Number appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;Ext.createDelegate(this.myFunction, this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(System.Delegate fn, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;Ext.createDelegate(this.myFunction, this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
		/// Will create a function that is automatically scoped to obj so that the this variable inside the
		/// callback points to obj. Example usage:
		/// 
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// </summary>
		/// <htmlSummary>
		/// Creates a delegate (callback) that sets the scope to obj.
		/// Call directly on any function. Example: &lt;code&gt;Ext.createDelegate(this.myFunction, this, [arg1, arg2])&lt;/code&gt;
		/// Will create a function that is automatically scoped to obj so that the &lt;tt&gt;this&lt;/tt&gt; variable inside the
		/// callback points to obj. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// // Note this use of &quot;this.text&quot; here. This function expects to
		/// // execute within a scope that contains a text property. In this
		/// // example, the &quot;this&quot; variable is pointing to the btn object that
		/// // was passed in createDelegate below.
		/// alert(&apos;Hi, &apos; + name + &apos;. You clicked the &quot;&apos; + this.text + &apos;&quot; button.&apos;);
		/// }
		///
		/// var btn = new Ext.Button({
		/// text: &apos;Say Hi&apos;,
		/// renderTo: Ext.getBody()
		/// });
		///
		/// // This callback will execute in the scope of the
		/// // button instance. Clicking the button alerts
		/// // &quot;Hi, Fred. You clicked the &quot;Say Hi&quot; button.&quot;
		/// btn.on(&apos;click&apos;, Ext.createDelegate(sayHi, btn, [&apos;Fred&apos;]));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <returns>The new function</returns>
		[ScriptName("createDelegate")]
		public System.Function CreateDelegate(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Delegate fn, System.Number millis, object scope, System.Array args, bool appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Delegate fn, System.Number millis, object scope, System.Array args, System.Number appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Delegate fn, System.Number millis, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Delegate fn, System.Number millis, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// 
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// </summary>
		/// <htmlSummary>
		/// Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// // executes immediately:
		/// sayHi(&apos;Fred&apos;);
		///
		/// // executes after 2 seconds:
		/// Ext.defer(sayHi, 2000, this, [&apos;Fred&apos;]);
		///
		/// // this syntax is sometimes useful for deferring
		/// // execution of an anonymous function:
		/// Ext.defer(function(){
		/// alert(&apos;Anonymous&apos;);
		/// }, 100);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public System.Number Defer(System.Delegate fn, System.Number millis)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Create a combined function call sequence of the original function + the passed function.
		/// The resulting function returns the results of the original function.
		/// The passed fcn is called with the parameters of the original function. Example usage:
		///
		///
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// var sayGoodbye = Ext.createSequence(sayHi, function(name){
		/// alert(&apos;Bye, &apos; + name);
		/// });
		///
		/// sayGoodbye(&apos;Fred&apos;); // both alerts show
		/// </summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="origFn">The original function.</param>
		/// <param name="newFn">The function to sequence</param>
		/// <param name="scope">
		/// The scope (this reference) in which the passed function is executed.
		/// If omitted, defaults to the scope in which the original function is called or the browser window.
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("createSequence")]
		public System.Function CreateSequence(System.Delegate origFn, System.Delegate newFn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Create a combined function call sequence of the original function + the passed function.
		/// The resulting function returns the results of the original function.
		/// The passed fcn is called with the parameters of the original function. Example usage:
		///
		///
		/// var sayHi = function(name){
		/// alert(&apos;Hi, &apos; + name);
		/// }
		///
		/// sayHi(&apos;Fred&apos;); // alerts &quot;Hi, Fred&quot;
		///
		/// var sayGoodbye = Ext.createSequence(sayHi, function(name){
		/// alert(&apos;Bye, &apos; + name);
		/// });
		///
		/// sayGoodbye(&apos;Fred&apos;); // both alerts show
		/// </summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="origFn">The original function.</param>
		/// <param name="newFn">The function to sequence</param>
		/// <returns>The new function</returns>
		[ScriptName("createSequence")]
		public System.Function CreateSequence(System.Delegate origFn, System.Delegate newFn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
